const express = require('express');
const router = express.Router();
const { PrismaClient } = require('@prisma/client');
const { authMiddleware } = require('../../middleware/auth');

// 创建 Prisma 客户端实例
let prisma;
try {
  prisma = new PrismaClient();
  console.log('Prisma 客户端创建成功');
} catch (error) {
  console.error('Prisma 客户端创建失败:', error);
  prisma = null;
}

router.use(authMiddleware);

// 获取价格工具列表数据
router.get('/list', async (req, res) => {
  console.log('收到价格工具列表请求，查询参数:', req.query);
  
  // 检查 Prisma 客户端是否可用
  if (!prisma) {
    return res.status(500).json({
      success: false,
      message: '数据库连接不可用'
    });
  }
  
  try {
    const { productName } = req.query;
    
    // 查询条件
    const where = {};
    if (productName) {
      where.name = {
        contains: productName,
        mode: 'insensitive'
      };
    }
    
    console.log('开始查询商品数据');
    
    // 获取所有商品
    const products = await prisma.product.findMany({
      where,
      select: {
        id: true,
        name: true,
        price: true,
        status: true,
        categoryId: true,
        category: {
          select: {
            id: true,
            name: true
          }
        }
      },
      orderBy: {
        name: 'asc'
      }
    });
    
    console.log(`查询到 ${products.length} 个商品`);
    
    // 获取所有渠道
    const channels = await prisma.channel.findMany({
      orderBy: {
        name: 'asc'
      }
    });
    
    console.log(`查询到 ${channels.length} 个渠道`);
    
    // 获取所有商品的渠道价格
    const productPrices = await prisma.productPrice.findMany({
      where: {
        productId: {
          in: products.map(p => p.id)
        }
      }
    });
    
    console.log(`查询到 ${productPrices.length} 个商品价格记录`);
    
    // 组装数据
    const formattedProducts = products.map(product => {
      return {
        productId: product.id,
        productName: product.name,
        standardPrice: product.price,
        status: product.status,
        categoryId: product.categoryId,
        categoryName: product.category?.name || '未分类',
        channelPrices: productPrices
          .filter(pp => pp.productId === product.id)
          .map(pp => ({
            id: pp.id,
            channelId: pp.channelId,
            price: pp.price
          }))
      };
    });
    
    console.log('数据组装完成，准备返回响应');
    
    // 返回成功响应
    return res.json({
      success: true,
      data: {
        products: formattedProducts,
        channels
      }
    });
  } catch (error) {
    console.error('获取价格工具列表数据失败:', error);
    return res.status(500).json({
      success: false,
      message: '获取价格工具列表数据失败',
      error: error.message
    });
  }
});

// 获取所有商品的价格工具设置
router.get('/', async (req, res) => {
  try {
    const priceSettings = await prisma.productPrice.findMany({
      include: {
        product: true,
        channel: true
      }
    });
    
    res.json({
      status: 'success',
      data: priceSettings
    });
  } catch (error) {
    console.error('获取价格工具设置失败:', error);
    res.status(500).json({
      status: 'error',
      message: '获取价格工具设置失败',
      error: error.message
    });
  }
});

// 批量更新价格
router.post('/batch-update', async (req, res) => {
  try {
    const { updates } = req.body;
    
    if (!updates || !Array.isArray(updates)) {
      return res.status(400).json({
        status: 'error',
        message: '无效的请求数据'
      });
    }
    
    const results = [];
    
    for (const update of updates) {
      const { id, price } = update;
      
      const result = await prisma.productPrice.update({
        where: { id },
        data: { price: parseFloat(price) }
      });
      
      results.push(result);
    }
    
    res.json({
      status: 'success',
      message: '价格已批量更新',
      data: results
    });
  } catch (error) {
    console.error('批量更新价格失败:', error);
    res.status(500).json({
      status: 'error',
      message: '批量更新价格失败',
      error: error.message
    });
  }
});

// 按百分比调整价格
router.post('/adjust-percentage', async (req, res) => {
  try {
    const { percentage, productIds, channelId } = req.body;
    
    if (!percentage || isNaN(percentage)) {
      return res.status(400).json({
        status: 'error',
        message: '无效的百分比值'
      });
    }
    
    const whereClause = {};
    if (productIds && Array.isArray(productIds)) {
      whereClause.productId = { in: productIds };
    }
    if (channelId) {
      whereClause.channelId = channelId;
    }
    
    // 获取当前价格
    const currentPrices = await prisma.productPrice.findMany({
      where: whereClause
    });
    
    // 更新价格
    const results = [];
    for (const priceRecord of currentPrices) {
      const newPrice = priceRecord.price * (1 + percentage / 100);
      
      const result = await prisma.productPrice.update({
        where: { id: priceRecord.id },
        data: { price: parseFloat(newPrice.toFixed(2)) }
      });
      
      results.push(result);
    }
    
    res.json({
      status: 'success',
      message: `价格已按${percentage}%调整`,
      data: {
        count: results.length,
        results
      }
    });
  } catch (error) {
    console.error('按百分比调整价格失败:', error);
    res.status(500).json({
      status: 'error',
      message: '按百分比调整价格失败',
      error: error.message
    });
  }
});

// 设置统一价格
router.post('/set-unified-price', async (req, res) => {
  try {
    const { productId, price } = req.body;
    
    if (!productId || !price || isNaN(price)) {
      return res.status(400).json({
        success: false,
        message: '无效的请求数据'
      });
    }
    
    // 获取所有渠道
    const channels = await prisma.channel.findMany();
    
    // 更新或创建每个渠道的价格
    const results = [];
    for (const channel of channels) {
      // 查找是否已存在价格记录
      const existingPrice = await prisma.productPrice.findFirst({
        where: {
          productId: parseInt(productId),
          channelId: channel.id
        }
      });
      
      let result;
      if (existingPrice) {
        // 更新现有价格
        result = await prisma.productPrice.update({
          where: { id: existingPrice.id },
          data: { price: parseFloat(price) }
        });
      } else {
        // 创建新价格记录
        result = await prisma.productPrice.create({
          data: {
            productId: parseInt(productId),
            channelId: channel.id,
            price: parseFloat(price)
          }
        });
      }
      
      results.push(result);
    }
    
    res.json({
      success: true,
      message: '价格已统一设置',
      data: results
    });
  } catch (error) {
    console.error('设置统一价格失败:', error);
    res.status(500).json({
      success: false,
      message: '设置统一价格失败',
      error: error.message
    });
  }
});

// 设置统一价格 (别名路由)
router.post('/set-price', async (req, res) => {
  try {
    const { productId, price } = req.body;
    
    if (!productId || !price || isNaN(price)) {
      return res.status(400).json({
        success: false,
        message: '无效的请求数据'
      });
    }
    
    // 获取所有渠道
    const channels = await prisma.channel.findMany();
    
    // 更新或创建每个渠道的价格
    const results = [];
    for (const channel of channels) {
      // 查找是否已存在价格记录
      const existingPrice = await prisma.productPrice.findFirst({
        where: {
          productId: parseInt(productId),
          channelId: channel.id
        }
      });
      
      let result;
      if (existingPrice) {
        // 更新现有价格
        result = await prisma.productPrice.update({
          where: { id: existingPrice.id },
          data: { price: parseFloat(price) }
        });
      } else {
        // 创建新价格记录
        result = await prisma.productPrice.create({
          data: {
            productId: parseInt(productId),
            channelId: channel.id,
            price: parseFloat(price)
          }
        });
      }
      
      results.push(result);
    }
    
    res.json({
      success: true,
      message: '价格已统一设置',
      data: results
    });
  } catch (error) {
    console.error('设置统一价格失败:', error);
    res.status(500).json({
      success: false,
      message: '设置统一价格失败',
      error: error.message
    });
  }
});

// 统一所有商品价格
router.post('/fix-all-prices', async (req, res) => {
  try {
    // 获取所有商品
    const products = await prisma.product.findMany({
      where: { status: true }
    });
    
    // 获取所有渠道
    const channels = await prisma.channel.findMany();
    
    // 处理每个商品
    const results = [];
    for (const product of products) {
      // 获取该商品在所有渠道的价格
      const productPrices = await prisma.productPrice.findMany({
        where: { productId: product.id }
      });
      
      // 如果没有任何渠道价格，使用标准价格
      let unifiedPrice = product.price;
      
      // 如果有渠道价格，找出最低的有效价格
      if (productPrices.length > 0) {
        const validPrices = productPrices
          .filter(pp => pp.price !== null && pp.price > 0)
          .map(pp => pp.price);
        
        if (validPrices.length > 0) {
          unifiedPrice = Math.min(...validPrices);
        }
      }
      
      // 为每个渠道设置统一价格
      for (const channel of channels) {
        // 查找是否已存在价格记录
        const existingPrice = await prisma.productPrice.findFirst({
          where: {
            productId: product.id,
            channelId: channel.id
          }
        });
        
        if (existingPrice) {
          // 更新现有价格
          await prisma.productPrice.update({
            where: { id: existingPrice.id },
            data: { price: unifiedPrice }
          });
        } else {
          // 创建新价格记录
          await prisma.productPrice.create({
            data: {
              productId: product.id,
              channelId: channel.id,
              price: unifiedPrice
            }
          });
        }
      }
      
      results.push({
        productId: product.id,
        productName: product.name,
        unifiedPrice
      });
    }
    
    res.json({
      success: true,
      message: '所有商品价格已统一',
      data: {
        count: results.length,
        results
      }
    });
  } catch (error) {
    console.error('统一所有商品价格失败:', error);
    res.status(500).json({
      success: false,
      message: '统一所有商品价格失败',
      error: error.message
    });
  }
});

module.exports = router; 